package com.sakura.system.controller.xycontroller;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.sakura.system.entity.xy.Card;
import com.sakura.system.entity.xy.CinemaResult;
import com.sakura.system.entity.xy.PageResult;
import com.sakura.system.service.impl.xyimpl.CardService;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.List;
@CrossOrigin
@RestController
@RequestMapping("${app.router.url}")
public class CardController {
    @Resource
    CardService cardService;
    /**
     * 获取会员卡数据的接口
     * @param memberId 会员ID
     * @param pageIndex 请求的页码
     * @param pageSize 每页显示的数据条数
     * @return 返回处理结果，包含分页后的卡数据列表和总页数
     */
    @RequestMapping("getCardData")
    public CinemaResult getCardData(String memberId, String pageIndex, String pageSize) {
        // 初始化分页结果对象
        PageResult pageResult = new PageResult();
        // 使用PageHelper插件开始分页
        PageHelper.startPage(Integer.parseInt(pageIndex), Integer.parseInt(pageSize));
        // 调用服务层方法获取会员卡数据
        List lists = cardService.getCardData(memberId);
        // 使用PageInfo包装分页信息
        PageInfo<Card> pageInfo = new PageInfo<>(lists);
        // 将分页数据填充到结果对象
        pageResult.setList(pageInfo.getList());
        pageResult.setPageTotal(pageInfo.getTotal());
        // 返回带有分页结果的OK响应
        return CinemaResult.ok(pageResult);
    }

    /**
     * //注册会员卡，请求参数无，返回状态
     * export const registerCard = query=>{
     * return request({
     * url:"registerCard",
     * method:'get',
     * params:query
     * });
     * };
     */
    /**
     * 注册会员卡
     * @param memberId 会员卡ID
     * @return 返回操作状态结果
     */
    @RequestMapping("registerCard")
    public CinemaResult registerCard(String memberId) {
        // 调用卡服务进行会员卡注册
        cardService.registerCard(memberId);
        // 返回操作成功的结果
        return CinemaResult.ok();
    }


    /**
     * //补卡，请求参数卡号id，返回新卡id号，并提示会员
     * export const reissueCard = query=>{
     * return request({
     * url:"reissueCard",
     * method:'post',
     * params:query
     * });
     * };
     */
    /**
     * 补卡操作，根据提供的卡号id，进行补卡处理，并返回新的卡号id。
     * @param cardId 需要补卡的卡号id。
     * @return 返回操作结果，其中包含新的卡号id。
     */
    @RequestMapping("reissueCard")
    public CinemaResult reissueCard(String cardId) {

        // 调用cardService中的reissueCard方法进行补卡操作，并返回新的卡号
        cardId = cardService.reissueCard(cardId);
        // 构造并返回操作成功的结果，包含新的卡号id
        return CinemaResult.ok(cardId);
    }


    /**
     * 挂失会员卡功能。
     * 接收一个会员卡ID作为参数，向服务器发送挂失请求。
     *
     * @param cardId 会员卡的唯一标识符，用于指定要挂失的会员卡。
     * @return 返回一个表示操作结果的CinemaResult对象，如果操作成功，则返回状态正常的CinemaResult对象。
     */
    @RequestMapping("loseCard")
    public CinemaResult loseCard(String cardId) {
        // 调用卡服务的挂失方法，处理挂失逻辑
        cardService.loseCard(cardId);
        // 返回操作成功的结果
        return CinemaResult.ok();
    }


    /**
     * 解挂会员卡接口
     * @param cardId 会员卡号，作为解挂请求的参数
     * @return 返回操作状态，成功返回ok
     */
    @RequestMapping("cancelCard")
    public CinemaResult cancelCard(String cardId) {
        // 调用卡服务进行解挂操作
        cardService.cancelCard(cardId);
        // 返回成功结果
        return CinemaResult.ok();
    }


    /**
     * 充值会员卡
     * @param cardId 会员卡号
     * @param value 充值金额，字符串形式
     * @return 返回操作状态，成功返回ok
     */
    @RequestMapping("rechargeCard")
    public CinemaResult rechargeCard(String cardId, String value) {

        // 调用卡服务进行会员卡充值
        cardService.rechargeCard(cardId, Integer.parseInt(value));
        // 返回操作成功结果
        return CinemaResult.ok();
    }


    /**
     * 消费卡内余额或积分。
     * @param cardId 卡号，标识进行消费的卡。
     * @param price 消费金额，以字符串形式传入，需转换为整数进行消费处理。
     * @param integral 消费积分，以字符串形式传入，需转换为整数进行消费处理。
     * @return 返回操作状态，成功返回ok。
     */
    @RequestMapping("consumeCard")
    public CinemaResult consumeCard(String cardId, String price, String integral) {

        // 调用卡服务进行消费操作，将传入的金额和积分转换为整数后作为参数
        cardService.consumeCard(cardId, Integer.parseInt(price), Integer.parseInt(integral));
        // 返回操作成功的结果
        return CinemaResult.ok();
    }


    /**
     * 积分兑换接口
     * 请求参数：memberId（会员id），integral（积分）
     * 由于是总积分兑换，所以需要将消耗的积分分散到所有卡上面
     * @param memberId 会员ID
     * @param integral 积分数量，字符串形式
     * @return 返回操作结果，成功返回ok
     */
    @RequestMapping("exchangeIntegral")
    public CinemaResult exchangeIntegral(String memberId, String integral) {

        // 调用卡服务进行积分兑换
        cardService.exchangeIntegral(memberId, Integer.parseInt(integral));
        // 返回成功结果
        return CinemaResult.ok();
    }

    /**
     * 通过模糊条件查询到cardId，请求参数memberId,CardId，返回CardId列表
     * @param memberId 会员ID，作为查询条件之一
     * @param cardId 卡号，作为查询条件之一
     * @return 返回查询到的CardId列表，封装在CinemaResult对象中
     */
    @RequestMapping("getCardIdByFuzzyQuery")
    public CinemaResult getCardIdByFuzzyQuery(String memberId,String cardId) {

        // 调用cardService中的getCardIdByFuzzyQuery方法，传入memberId和cardId，返回查询结果
        return CinemaResult.ok(cardService.getCardIdByFuzzyQuery(memberId,cardId));
    }

    /**
     * 通过完整的cardId来查询card数据，返回Card对象
     * @param cardId 查询条件，卡的完整ID
     * @return 返回根据卡ID查询到的Card对象，封装在CinemaResult中
     */
    @RequestMapping("getCardByCardId")
    public CinemaResult getCardByCardId(String cardId) {
        // 调用cardService中的getCardByCardId方法查询卡信息，并将结果封装为CinemaResult返回
        return CinemaResult.ok(cardService.getCardByCardId(cardId));
    }

}
